package cn.com.utils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * 安全获取实用程序
 * 避免空指针异常
 *
 * @author LiuGuodong
 * @date 2023/12/20
 */
public class SafeGetUtil {

    // 私有构造函数，防止实例化
    private SafeGetUtil() {
    }

    /**
     * 安全获取字符串，避免空指针异常
     */
    public static String getString(String value) {
        return Optional.ofNullable(value).orElse("");
    }

    /**
     * 安全获取字符串，处理Integer类型
     */
    public static String getString(Integer value) {
        return Optional.ofNullable(value).map(String::valueOf).orElse("");
    }

    /**
     * 安全获取字符串，处理Double类型
     */
    public static String getString(Double value) {
        return Optional.ofNullable(value).map(String::valueOf).orElse("");
    }

    /**
     * 安全获取字符串，处理Boolean类型
     */
    public static String getString(Boolean value) {
        return Optional.ofNullable(value).map(String::valueOf).orElse("");
    }

    /**
     * 安全获取集合，避免空指针异常
     */
    public static <T> Collection<T> getCollection(Collection<T> collection) {
        return Optional.ofNullable(collection).orElse(Collections.emptySet());
    }

    /**
     * 安全获取集合，避免空指针异常
     */
    public static <T> List<T> getList(List<T> collection) {
        return Optional.ofNullable(collection).orElse(Collections.emptyList());
    }

    /**
     * 安全获取第一个元素
     */
    public static <T> T getFirst(Collection<T> value) {
        return Optional.ofNullable(value).orElse(new ArrayList<>())
                .stream()
                .findFirst()
                .orElse((T) new Object());
    }

    /**
     * 安全获取数组，避免空指针异常
     */
    public static <T> T[] getArray(T[] array) {
        return Optional.ofNullable(array).orElse(Arrays.copyOf(array, 0));
    }

    /**
     * 安全获取Map，避免空指针异常
     */
    public static <K, V> Map<K, V> getMap(Map<K, V> map) {
        return Optional.ofNullable(map).orElse(Collections.emptyMap());
    }


    /**
     * 安全获取 Integer，避免空指针异常
     */
    public static Integer getInteger(Integer value) {
        return Optional.ofNullable(value).orElse(0);
    }

    /**
     * 安全获取 Integer，处理String类型
     */
    public static Integer getInteger(String value) {
        try {
            return Optional.ofNullable(value).map(Integer::parseInt).orElse(0);
        } catch (NumberFormatException e) {
            return 0; // or handle the exception as per your requirement
        }
    }

    /**
     * 安全获取 Integer，处理Double类型
     */
    public static Integer getInteger(Double value) {
        return Optional.ofNullable(value).map(Double::intValue).orElse(0);
    }

    /**
     * 安全获取 Integer，处理Boolean类型
     */
    public static Integer getInteger(Boolean value) {
        return Optional.ofNullable(value).map(b -> b ? 1 : 0).orElse(0);
    }

    /**
     * 安全获取 Integer，避免空指针异常
     */
    public static Integer getInteger(BigDecimal value) {
        return Optional.ofNullable(value).orElse(BigDecimal.ZERO).intValue();
    }

    /**
     * 安全获取 Long，避免空指针异常
     */
    public static Long getLong(Long value) {
        return Optional.ofNullable(value).orElse(0L);
    }

    /**
     * 安全获取 long，处理Integer类型
     */
    public static Long getLong(Integer value) {
        return Optional.ofNullable(value).map(Long::valueOf).orElse(0L);
    }

    /**
     * 安全获取 long，处理Double类型
     */
    public static Long getLong(Double value) {
        return Optional.ofNullable(value).map(Double::longValue).orElse(0L);
    }

    /**
     * 安全获取 long，处理Float类型
     */
    public static Long getLong(Float value) {
        return Optional.ofNullable(value).map(Float::longValue).orElse(0L);
    }

    /**
     * 安全获取 long，处理String类型
     */
    public static Long getLong(String value) {
        try {
            return Optional.ofNullable(value).map(Long::parseLong).orElse(0L);
        } catch (NumberFormatException e) {
            return 0L; // or handle the exception as per your requirement
        }
    }

    /**
     * 安全获取 Long，避免空指针异常
     */
    public static Long getLong(BigDecimal value) {
        return Optional.ofNullable(value).orElse(BigDecimal.ZERO).longValue();
    }

    /**
     * 安全获取 Double，避免空指针异常
     */
    public static Double getDouble(Double value) {
        return Optional.ofNullable(value).orElse(0.0);
    }

    /**
     * 安全获取 Double，避免空指针异常
     */
    public static Double getDouble(BigDecimal value) {
        return Optional.ofNullable(value).orElse(BigDecimal.ZERO).doubleValue();
    }

    /**
     * 安全获取 Float，避免空指针异常
     */
    public static Float getFloat(Float value) {
        return Optional.ofNullable(value).orElse(0.0f);
    }

    /**
     * 安全获取 Float，处理String类型
     */
    public static Float getFloat(String value) {
        try {
            return Optional.ofNullable(value).map(Float::parseFloat).orElse(0.0f);
        } catch (NumberFormatException e) {
            return 0.0f; // or handle the exception as per your requirement
        }
    }

    /**
     * 安全获取 Float，处理Double类型
     */
    public static Float getFloat(Double value) {
        return Optional.ofNullable(value).map(Double::floatValue).orElse(0.0f);
    }

    /**
     * 安全获取 Float，处理Integer类型
     */
    public static Float getFloat(Integer value) {
        return Optional.ofNullable(value).map(Integer::floatValue).orElse(0.0f);
    }

    /**
     * 安全获取 Float，处理BigDecimal类型
     */
    public static Float getFloat(BigDecimal value) {
        return Optional.ofNullable(value).orElse(BigDecimal.ZERO).floatValue();
    }

    /**
     * 安全获取 BigDecimal，避免空指针异常
     */
    public static BigDecimal getBigDecimal(BigDecimal value) {
        return Optional.ofNullable(value).orElse(BigDecimal.ZERO);
    }


    /**
     * 安全获取 BigDecimal，处理String类型
     */
    public static BigDecimal getBigDecimal(String value) {
        try {
            return new BigDecimal(value);
        } catch (NumberFormatException | NullPointerException e) {
            return BigDecimal.ZERO; // or handle the exception as per your requirement
        }
    }

    /**
     * 安全获取 BigDecimal，处理Double类型
     */
    public static BigDecimal getBigDecimal(Double value) {
        return Optional.ofNullable(value).map(BigDecimal::valueOf).orElse(BigDecimal.ZERO);
    }

    /**
     * 安全获取 BigDecimal，处理Integer类型
     */
    public static BigDecimal getBigDecimal(Integer value) {
        return Optional.ofNullable(value).map(BigDecimal::valueOf).orElse(BigDecimal.ZERO);
    }


    /**
     * 安全获取 Data 毫秒值，避免空指针异常
     */
    public static long getTime(Date value) {
        return Optional.ofNullable(value).map(Date::getTime).orElse(0L);
    }

}
